package demo;

import java.awt.*;
import java.util.Arrays;

//练习顺序表
public class MyArrayList implements IList{
    //定义一个数组
    public int[] elem;
    //定义顺序表中有效元素的数量
    public int usedSize;//默认值为0
    //定义一个常量，放入定义数组里面
    public static final int DEFAULT_CAPACITY = 5;

    //构造方法（在构造方法里面对数组进行初始化）
    public MyArrayList() {
        elem = new int[DEFAULT_CAPACITY];
    }

    //完成以上设置之后，让 MyArrayList 实现 IList 接口  重写里面的方法

    /**
     * 尾插法 在数组的最后添加元素
     * 需要考虑的问题：
     * 1.数组是否满了，要是满了要进行扩容
     * @param data 数据
     */
    @Override
    public void add(int data) {
        if (isFull()){
            elem = Arrays.copyOf(elem,2 * elem.length);
        }
        elem[usedSize] = data;
        usedSize++;
    }

    /**
     * 在指定位置插入元素
     * 需要考虑的问题：
     * 指定位置下标是否 合法  pos 位置需要进行判断
     * 数组长度是否要扩容
     * @param pos  指定位置下标
     * @param data 数据
     */
    @Override
    public void add(int pos, int data) {
        checkPosOfAdd(pos);
        if (isFull()){
            elem = Arrays.copyOf(elem,2 * elem.length);
        }
        for (int i = usedSize - 1; i >= pos; i--) {
            elem[i + 1] = elem[i];
        }
        elem[pos] = data;
    }

    private void checkPosOfAdd(int pos){
        if (pos < 0 || pos > usedSize){
            throw new PosEception("pos位置为：" + pos);
        }
    }

    /**
     * 判定是否包含某个元素
     * @param toFind  查找的意思
     * @return
     */
    @Override
    public boolean contains(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if (elem[i] == toFind){
                return true;
            }
        }
        return false;
    }

    /**
     * 查找当前元素的下标
     * @param toFind
     * @return
     */
    @Override
    public int indexOf(int toFind) {
        for (int i = 0; i < usedSize; i++) {
            if (elem[i] == toFind){
                return i;
            }
        }
        return -1;
    }

    /**
     * 获取 pos 位置的元素
     * 需要考虑的问题：
     * 1.pos位置不合法
     * 2.数组为空怎么办？
     * @param pos
     * @return
     */
    @Override
    public int get(int pos) {
        checkPosOfGet(pos);
        if (isEmpty()){
            throw new EmptyEception("顺序表为空！");
        }
        return elem[pos];
    }
    private void checkPosOfGet(int pos){
        if (pos < 0 || pos >= this.usedSize){
            throw new PosEception("pos位置为：" + pos);
        }
    }

    /**
     * 给 pos 位置的元素设为 value
     * @param pos
     * @param value
     */
    @Override
    public void set(int pos, int value) {
        checkPosOfGet(pos);
        if (isEmpty()){
            throw new EmptyEception("顺序表为空！");
        }
        this.elem[pos] = value;
    }

    /**
     * 删除 toRemove 这个数
     * 顺序表不能为空
     * @param toRemove
     */
    @Override
    public void remove(int toRemove) {
        if (isEmpty()){
            throw new EmptyEception("顺序表为空，不能删除！");
        }

        int index = indexOf(toRemove);
        for (int i = index; i < usedSize - 1; i++) {
            elem[i] = elem[i + 1];
        }
        usedSize--;
    }

    /**
     *
     * @return
     */
    @Override
    public int size() {

        return this.usedSize;
    }

    /**
     * 清空顺序表，防止内存泄漏
     */
    @Override
    public void clear() {
        usedSize = 0;
    }

    /**
     * 打印顺序表，注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
     */
    @Override
    public void display() {
        for (int i = 0; i < usedSize; i++) {
            System.out.print(elem[i] + " ");
        }
        System.out.println();
    }

    /**
     * 判断数组是否满了
     * @return
     */
    @Override
    public boolean isFull() {
        return elem.length == usedSize;
    }

    /**
     * 判断数组是否为空
     * @return
     */
    @Override
    public boolean isEmpty() {
        return usedSize == 0;
    }


}
